/**
 * 检测内容的类型，返回值：Object，Array，String，Number，Null，Undefined
 * @param e 要检测类型的内容
 */
 function checkType(e) {
    if(e) {
        const result = Object.prototype.toString.call(e)
        if(result) {
            const __result = result.replace('object', '').replace('[', '').replace(']', '').replace(' ', '')
            return __result
        }
    }
}

/**
 * 节流函数 一个函数执行一次后，只有大于设定的执行周期才会执行第二次。有个需要频繁触发的函数，出于优化性能的角度，在规定时间内，只让函数触发的第一次生效，后面的不生效。
 * @param fn 要被节流的函数
 * @param delay 规定的时间
 */
function throttle(fn, delay) {
    //记录上一次函数触发的时间
    var lastTime = 0;
    return function(){
        //记录当前函数触发的时间
        var nowTime = Date.now();
        if(nowTime - lastTime > delay){
            //修正this指向问题
            fn.call(this);
            //同步执行结束时间
            lastTime = nowTime;
        }
    }
}

/**
 * 防抖函数  一个需要频繁触发的函数，在规定时间内，只让最后一次生效，前面的不生效
 * @param fn 要被节流的函数
 * @param delay 规定的时间
 */
 function debounce(fn, delay) {
    //记录上一次的延时器
    var timer = null;
    return function () {
       //清除上一次的演示器
        clearTimeout(timer);
        //重新设置新的延时器
        timer = setTimeout(function(){
            //修正this指向问题
            fn.apply(this);
        }, delay); 
    }
}

/**
 * 对数组进行排序
 * @param arr 要排序的数组
 * @param key 要排序的对象key
 */
function sortTest(arr, key) {
    // 数组排序
    if(checkType(arr) === 'Array') {
        if(key) {
            return arr.sort((a, b) => a[key] - b[key])
        }else{
            return arr.sort()
        }  
    }
}

/**
 * 对数组或者字符串去重
 * @param value 要去重的值
 * @param key value为数组且items为object时要去重的object的key
 */
function repeatValue(value, key) {
    if(checkType(value) === 'Array') {
        if(key) {
            let obj = {}
            // return value.reduce((cur, next) => {
            //     obj[next[key]] ? "" : obj[next[key]] = true && cur.push(next)
            //     return cur
            // }, [])
            // 循环value，当obj在对应key是false的时候就赋值为true并push一次，key为相同是就不会再push，所以达到去重效果
            let cur = []
            value.map((i, k) => {
                obj[i[key]] || (obj[i[key]] = true && cur.push(i))
            }) 
            return cur
        }else{
            return [...new Set(value)]
            
        }
    }
    if(checkType(value) == 'String') {
        return [...new Set(value)].join('')
    }
}
 
/**
 * 时间戳转换时间
 * @param time 要转换的时间戳
 */
function formatTime(time) {
    // 判断时间戳长度
	const date = (time + '').length == 13 ? new Date(time) : new Date(time * 1000)
	const year = date.getFullYear()
	const month = date.getMonth() + 1
	const day = date.getDate()
	const hour = date.getHours()
	const minute = date.getMinutes()
	const second = date.getSeconds()
	return [year, month, day].map(formatNumber).join('-') + ' ' + [hour, minute, second].map(formatNumber).join(':')
}

function formatNumber(n) {
    n = n.toString()
	return n[1] ? n : '0' + n
}

/**
 * 金额计算结果格式化，精确值，防止计算结果小数点后长度溢出
 * @param value 要格式化的值
 * @param digit 精确值
 */
function formatFloat(value, digit = 2) {
    const res = Number(value)
    // 判断是否为整数 
    if(Number.isInteger(res)) {
        return res.toFixed(digit)
    }else{
        return Math.round(res * Math.pow(10, digit)) / Math.pow(10, digit) 
    }
}

/**
 * 验证手机
 * @param mobile 手机号码
 */
export const checkMobile = mobile => /^1[3456789]\d{9}$/.test(mobile)

/**
 * 验证邮箱
 * @param email 手机号码
 */
export const checkEmail = email => /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/.test(email)

/**
 * 验证是否有中文
 * @param pw 密码
 */
export const checkPW = pw => /^[^\u4e00-\u9fa5]{0,}$/.test(pw)